{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# import "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.set_autosave_interval(60000)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Autosaving every 60 seconds\n"
     ]
    }
   ],
   "source": [
    "%autosave 60\n",
    "import os\n",
    "import sys\n",
    "import pprint\n",
    "import time\n",
    "import datetime\n",
    "import random\n",
    "\n",
    "import threading\n",
    "import subprocess\n",
    "\n",
    "\n",
    "from dir_objectName import dir_objectName\n",
    "\n",
    "import logging\n",
    "logging.basicConfig(level=logging.INFO,\n",
    "                    format=\" %(asctime)s - %(levelname)s - %(message)s \")\n",
    "#!/Users/mach711/myproject/venv_python3/bin/python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 保持时间、计划任务和启动程序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## time 模块"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算机的系统时钟设置为特定的日期、时间和时区\n",
    "\n",
    "内置的 time 模块让 Python程序能读取系统时钟的当前时间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### time.time()函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Unix 纪元是编程中经常参考的时间： 1970 年 1 月 1 日 0 点，即协调世界时（ UTC）。 \n",
    "\n",
    "time.time()函数返回自那一刻以来的秒数，是一个浮点值， 这个数字称为 UNIX 纪元时间戳\n",
    "\n",
    "调用time.time()。返回值是 Unix 纪元的那一刻与 time.time()被调用的那一刻之间的秒数\n",
    "\n",
    "---\n",
    "\n",
    "另一种剖析代码的方法是利用 cProfile.run()函数。与简单的 time.time()技术相比，它提供了详细的信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test():\n",
    "    for i in range(1000):\n",
    "        for j in range(1000):\n",
    "            i = i + j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50004999 5.220503091812134\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "test()\n",
    "end = time.time()\n",
    "print(i, end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cProfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         4 function calls in 5.171 seconds\n",
      "\n",
      "   Ordered by: standard name\n",
      "\n",
      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
      "        1    5.171    5.171    5.171    5.171 <ipython-input-8-d1170c860a41>:1(test)\n",
      "        1    0.000    0.000    5.171    5.171 <string>:1(<module>)\n",
      "        1    0.000    0.000    5.171    5.171 {built-in method builtins.exec}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "cProfile.run('test()')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### time.sleep()函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 IDLE 中按 Ctrl-C 不会中断 time.sleep()调用。 \n",
    "\n",
    "IDLE 会等待到暂停结束，再抛出 KeyboardInterrupt 异常。\n",
    "\n",
    "要绕过这个问题，不要用一次 time.sleep(30)调用来暂停 30 秒，\n",
    "\n",
    "而是使用 for 循环执行 30 次 time.sleep(1)调用\n",
    "\n",
    "---\n",
    "如果在这 30 秒内的某个时候按 Ctrl-C， 应该马上看到抛出 KeyboardInterrupt 异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(30):\n",
    "    time.sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 项目：超级秒表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "总的来说，你的程序需要完成：\n",
    "\n",
    "- 记录从按下回车键开始，每次按键的时间，每次按键都是一个新的“单圈”。\n",
    "\n",
    "- 打印圈数、总时间和单圈时间。\n",
    "\n",
    "---\n",
    "这意味着代码将需要完成以下任务：\n",
    "\n",
    "- 在程序开始时，通过调用 time.time()得到当前时间，将它保存为一个时间戳。在每个单圈开始时也一样。\n",
    "\n",
    "- 记录圈数，每次用户按下回车键时加 1。\n",
    "\n",
    "- 用时间戳相减，得到计算流逝的时间。\n",
    "\n",
    "- 处理 KeyboardInterrupt 异常，这样用户可以按 Ctrl-C 退出。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Press \u001b[41mENTER\u001b[0m to begin. Afterwards, press ENTER to \"click\" the stopwatch.\n",
      "Press \u001b[42mCtrl-C\u001b[0m to quit.\n",
      "\n",
      "\n",
      "Started.\n",
      "\n",
      "Lap #1: 1.01 (1.01)\n",
      "Lap #2: 2.01 (1.0)exit\n",
      "Lap #3: 5.79 (3.78)\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "# Display the program's instructions.\n",
    "print('''\n",
    "Press \\033[41mENTER\\033[0m to begin. Afterwards, press ENTER to \"click\" the stopwatch.\n",
    "Press \\033[42mCtrl-C\\033[0m to quit.\n",
    "''')\n",
    "input() # press Enter to begin\n",
    "print('Started.')\n",
    "startTime = time.time() # get the first lap's start time\n",
    "lastTime = startTime\n",
    "lapNum = 1\n",
    "\n",
    "# Start tracking the lap times.\n",
    "try:\n",
    "    while True:\n",
    "        stop = input()\n",
    "        lapTime = round(time.time() - lastTime, 2)\n",
    "        totalTime = round(time.time() - startTime, 2)\n",
    "        print('Lap #%s: %s (%s)' % (lapNum, totalTime, lapTime), end='')\n",
    "        lapNum += 1\n",
    "        lastTime = time.time() # reset the last lap time\n",
    "        if 'exit' == stop.lower():\n",
    "            raise KeyboardInterrupt\n",
    "except KeyboardInterrupt:\n",
    "    # Handle the Ctrl-C exception to keep its error message from displaying.\n",
    "    print('\\nDone.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[41m7@@\u001b[0maltzone                       \u001b[41m8@@\u001b[0masctime                       \n",
      "\u001b[41m9@@\u001b[0mctime                         \u001b[41m10@\u001b[0mdaylight                      \u001b[41m11@\u001b[0mget_clock_info                \u001b[41m12@\u001b[0mgmtime                        \n",
      "\u001b[41m13@\u001b[0mlocaltime                     \u001b[41m14@\u001b[0mmktime                        \u001b[41m15@\u001b[0mmonotonic                     \u001b[41m16@\u001b[0mmonotonic_ns                  \n",
      "\u001b[41m17@\u001b[0mperf_counter                  \u001b[41m18@\u001b[0mperf_counter_ns               \u001b[41m19@\u001b[0mprocess_time                  \u001b[41m20@\u001b[0mprocess_time_ns               \n",
      "\u001b[41m21@\u001b[0msleep                         \u001b[41m22@\u001b[0mstrftime                      \u001b[41m23@\u001b[0mstrptime                      \u001b[41m24@\u001b[0mstruct_time                   \n",
      "\u001b[41m25@\u001b[0mthread_time                   \u001b[41m26@\u001b[0mthread_time_ns                \u001b[41m27@\u001b[0mtime                          \u001b[41m28@\u001b[0mtime_ns                       \n",
      "\u001b[41m29@\u001b[0mtimezone                      \u001b[41m30@\u001b[0mtzname                        "
     ]
    }
   ],
   "source": [
    "dir_objectName(time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## datetime 模块"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "time 模块用于取得 Unix 纪元时间戳\n",
    "\n",
    "datetime 模块以更方便的格式显示日期，或对日期进行算术运算\n",
    "\n",
    "（例如，搞清楚 205 天前是什么日期，或 123天后是什么日期）\n",
    "\n",
    "\n",
    "调用 datetime.datetime.fromtimestamp()并传入 1000000，返回一个 datetime 对象， 表示 Unix 纪元后 1000000 秒的时刻。\n",
    "\n",
    "传入 time.time()，即当前时刻的 Unix 纪元时间戳，则返回当前时刻的 datetime 对象。\n",
    "\n",
    "因此，表达式 datetime.datetime.now()和 datetime.datetime.fromtimestamp(time.time())做的事情相同，它们都返回当前时刻的 datetime 对象\n",
    "\n",
    "datetime 对象可以用<font color=red>比较</font>操作符进行比较"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### datetime  对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2021, 2, 9, 17, 32, 9, 793223)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2021-02-09 17:52:39.374543'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(datetime.datetime.now())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.now().month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[41m28@\u001b[0mastimezone                    \n",
      "\u001b[41m29@\u001b[0mcombine                       \u001b[41m30@\u001b[0mctime                         \u001b[41m31@\u001b[0mdate                          \u001b[41m32@\u001b[0mday                           \n",
      "\u001b[41m33@\u001b[0mdst                           \u001b[41m34@\u001b[0mfold                          \u001b[41m35@\u001b[0mfromisocalendar               \u001b[41m36@\u001b[0mfromisoformat                 \n",
      "\u001b[41m37@\u001b[0mfromordinal                   \u001b[41m38@\u001b[0mfromtimestamp                 \u001b[41m39@\u001b[0mhour                          \u001b[41m40@\u001b[0misocalendar                   \n",
      "\u001b[41m41@\u001b[0misoformat                     \u001b[41m42@\u001b[0misoweekday                    \u001b[41m43@\u001b[0mmax                           \u001b[41m44@\u001b[0mmicrosecond                   \n",
      "\u001b[41m45@\u001b[0mmin                           \u001b[41m46@\u001b[0mminute                        \u001b[41m47@\u001b[0mmonth                         \u001b[41m48@\u001b[0mnow                           \n",
      "\u001b[41m49@\u001b[0mreplace                       \u001b[41m50@\u001b[0mresolution                    \u001b[41m51@\u001b[0msecond                        \u001b[41m52@\u001b[0mstrftime                      \n",
      "\u001b[41m53@\u001b[0mstrptime                      \u001b[41m54@\u001b[0mtime                          \u001b[41m55@\u001b[0mtimestamp                     \u001b[41m56@\u001b[0mtimetuple                     \n",
      "\u001b[41m57@\u001b[0mtimetz                        \u001b[41m58@\u001b[0mtoday                         \u001b[41m59@\u001b[0mtoordinal                     \u001b[41m60@\u001b[0mtzinfo                        \n",
      "\u001b[41m61@\u001b[0mtzname                        \u001b[41m62@\u001b[0mutcfromtimestamp              \u001b[41m63@\u001b[0mutcnow                        \u001b[41m64@\u001b[0mutcoffset                     \n",
      "\u001b[41m65@\u001b[0mutctimetuple                  \u001b[41m66@\u001b[0mweekday                       \u001b[41m67@\u001b[0myear                          "
     ]
    }
   ],
   "source": [
    "dir_objectName(datetime.datetime.now())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt = datetime.datetime(2020, 2, 9)\n",
    "dt.year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### datetime对象 加减运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(datetime.timedelta(days=-367, seconds=21953, microseconds=60085),\n",
       " '-367 days, 6:05:53.060085')"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difference = dt - datetime.datetime.now()\n",
    "difference, str(difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "difference.total_seconds()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### unix时间戳 ----》 datetime对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1612863468.7847996"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(1970, 1, 12, 21, 46, 40)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.fromtimestamp(1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2021, 2, 9, 17, 38, 15, 177198)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.fromtimestamp(time.time())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### datetime 对象比较"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "halloween2015 = datetime.datetime(2015, 10, 31, 0, 0, 0)\n",
    "newyears2016 = datetime.datetime(2016, 1, 1, 0, 0, 0)\n",
    "oct31_2015 = datetime.datetime(2015, 10, 31, 0, 0, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "halloween2015 == oct31_2015"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "halloween2015 > newyears2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " newyears2016 > halloween2015"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newyears2016 != oct31_2015"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### timedelta 数据类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "datetime 模块还提供了 timedelta 数据类型，它表示<font color=red>一段时间</font>，而不是一个时刻\n",
    "\n",
    "timedelta 对象拥有的总时间以天、秒、微秒来表示\n",
    "\n",
    "这些数字分别保存在 days、 seconds 和 microseconds 属性中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(81, 36548, 11000)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delta = datetime.timedelta( weeks=10, days=11, hours=10, minutes=9, seconds=8, \n",
    "                           microseconds=1000, milliseconds=10)\n",
    "delta.days, delta.seconds, delta.microseconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[41m42@\u001b[0mdays                          \u001b[41m43@\u001b[0mmax                           \u001b[41m44@\u001b[0mmicroseconds                  \n",
      "\u001b[41m45@\u001b[0mmin                           \u001b[41m46@\u001b[0mresolution                    \u001b[41m47@\u001b[0mseconds                       \u001b[41m48@\u001b[0mtotal_seconds                 \n"
     ]
    }
   ],
   "source": [
    "dir_objectName(delta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'81 days, 10:09:08.011000'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(delta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### datetime对象与deltatime对象 加减运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2015, 10, 21, 16, 29)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oct21st = datetime.datetime(2015, 10, 21, 16, 29, 0)\n",
    "oct21st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(datetime.timedelta(days=10950), '10950 days, 0:00:00')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aboutThirtyYears = datetime.timedelta(days=365 * 30)\n",
    "aboutThirtyYears, str(aboutThirtyYears)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(datetime.datetime(1985, 10, 28, 16, 29), '1985-10-28 16:29:00')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oct21st - aboutThirtyYears, str(oct21st - aboutThirtyYears)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(1955, 11, 5, 16, 29)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oct21st - (2 * aboutThirtyYears)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### time.sleep()  暂停直至特定日期"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "halloween2016 = datetime.datetime(2016, 10, 31, 0, 0, 0)\n",
    "while datetime.datetime.now() < halloween2016:\n",
    "    time.sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将 datetime 对象转换为字符串"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unix 纪元时间戳和 datetime 对象对人类来说都不是很友好可读。\n",
    "\n",
    "利用 strftime()方法，可以将 datetime 对象显示为字符串。（strftime()函数名中的 f 表示格式， format）\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2015/10/21 16:29:00'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oct21st = datetime.datetime(2015, 10, 21, 16, 29, 0)\n",
    "oct21st.strftime('%Y/%m/%d %H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2021/02/12 22:11:15'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " datetime.datetime.strftime(datetime.datetime.now(), '%Y/%m/%d %H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2015-10-21 16:29:00'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(oct21st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'04:29 PM'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oct21st.strftime('%I:%M %p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"October of '15\""
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oct21st.strftime(\"%B of '%y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将字符串转换成 datetime 对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要从字符串'October 21, 2015'取得一个 datetime 对象，\n",
    "\n",
    "将'October 21, 2015'作为第一个参数传递给 strptime()，\n",
    "\n",
    "并将对应于'October 21, 2015' 的定制格式字符串作为第二个参数。\n",
    "\n",
    "带有日期信息的字符串必须准确匹配定制的格式字符串，否则 Python将抛出 ValueError 异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2015, 10, 21, 0, 0)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.strptime('October 21, 2015', '%B %d, %Y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2015, 10, 21, 16, 29)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.strptime('2015/10/21 16:29:00', '%Y/%m/%d %H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2015, 10, 21, 16, 29)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oct21st.strptime(str(oct21st), '%Y-%m-%d %H:%M:%S')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多线程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start of program.\n",
      "\u001b[41mEnd of program.\u001b[0m\n",
      "Wake up!\n"
     ]
    }
   ],
   "source": [
    "print('Start of program.')\n",
    "def takeANap():\n",
    "    time.sleep(5)\n",
    "    print('Wake up!')\n",
    "threadObj = threading.Thread(target=takeANap)\n",
    "threadObj.start()\n",
    "print('\\033[41mEnd of program.\\033[0m')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[41m46@\u001b[0mdaemon                        \u001b[41m47@\u001b[0mgetName                       \u001b[41m48@\u001b[0mident                         \n",
      "\u001b[41m49@\u001b[0misAlive                       \u001b[41m50@\u001b[0misDaemon                      \u001b[41m51@\u001b[0mis_alive                      \u001b[41m52@\u001b[0mjoin                          \n",
      "\u001b[41m53@\u001b[0mname                          \u001b[41m54@\u001b[0mnative_id                     \u001b[41m55@\u001b[0mrun                           \u001b[41m56@\u001b[0msetDaemon                     \n",
      "\u001b[41m57@\u001b[0msetName                       \u001b[41m58@\u001b[0mstart                         "
     ]
    }
   ],
   "source": [
    "dir_objectName(threadObj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 向线程的目标函数传递参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "threads can only be started once",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-81-891dcb5b7f72>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m hreadObj = threading.Thread(target=print, args=['Cats', 'Dogs', 'Frogs'],\n\u001b[0;32m      2\u001b[0m                             kwargs={'sep': ' & '})\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mthreadObj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstart\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\threading.py\u001b[0m in \u001b[0;36mstart\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    846\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    847\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_started\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mis_set\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 848\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"threads can only be started once\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    849\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0m_active_limbo_lock\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    850\u001b[0m             \u001b[0m_limbo\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mRuntimeError\u001b[0m: threads can only be started once"
     ]
    }
   ],
   "source": [
    "hreadObj = threading.Thread(target=print, args=['Cats', 'Dogs', 'Frogs'],\n",
    "                            kwargs={'sep': ' & '})\n",
    "threadObj.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cats & Dogs & Frogs\n"
     ]
    }
   ],
   "source": [
    "hreadObj_print = threading.Thread(target=print, args=['Cats', 'Dogs', 'Frogs'],\n",
    "                            kwargs={'sep': ' & '})\n",
    "hreadObj_print.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 并发问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了避免并发问题，绝不让多个线程读取或写入相同的变量。\n",
    "\n",
    "当创建一个新的 Thread 对象时，要确保其目标函数只使用该函数中的局部变量。\n",
    "\n",
    "这将避免程序中难以调试的并发问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 项目：多线程 XKCD 下载程序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, initial)>]\n",
      "Downloading page http://xkcd.com/0...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, initial)>]\n",
      "Downloading page http://xkcd.com/100...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, initial)>]\n",
      "Downloading page http://xkcd.com/200...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, initial)>]\n",
      "Downloading page http://xkcd.com/300...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, initial)>]\n",
      "Downloading page http://xkcd.com/400...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, initial)>]\n",
      "Downloading page http://xkcd.com/500...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, initial)>]\n",
      "Downloading page http://xkcd.com/600...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, started 13032)>, <Thread(Thread-56, initial)>]\n",
      "Downloading page http://xkcd.com/700...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, started 13032)>, <Thread(Thread-56, started 6616)>, <Thread(Thread-57, initial)>]\n",
      "Downloading page http://xkcd.com/800...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, started 13032)>, <Thread(Thread-56, started 6616)>, <Thread(Thread-57, started 11756)>, <Thread(Thread-58, initial)>]\n",
      "Downloading page http://xkcd.com/900...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, started 13032)>, <Thread(Thread-56, started 6616)>, <Thread(Thread-57, started 11756)>, <Thread(Thread-58, started 3872)>, <Thread(Thread-59, initial)>]\n",
      "Downloading page http://xkcd.com/1000...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, started 13032)>, <Thread(Thread-56, started 6616)>, <Thread(Thread-57, started 11756)>, <Thread(Thread-58, started 3872)>, <Thread(Thread-59, started 5888)>, <Thread(Thread-60, initial)>]\n",
      "Downloading page http://xkcd.com/1100...\n",
      "\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, started 13032)>, <Thread(Thread-56, started 6616)>, <Thread(Thread-57, started 11756)>, <Thread(Thread-58, started 3872)>, <Thread(Thread-59, started 5888)>, <Thread(Thread-60, started 4092)>, <Thread(Thread-61, initial)>]\n",
      "Downloading page http://xkcd.com/1200...\u001b[41mdownloadThreads\u001b[0m [<Thread(Thread-49, started 6268)>, <Thread(Thread-50, started 12728)>, <Thread(Thread-51, started 8952)>, <Thread(Thread-52, started 6700)>, <Thread(Thread-53, started 8980)>, <Thread(Thread-54, started 3216)>, <Thread(Thread-55, started 13032)>, <Thread(Thread-56, started 6616)>, <Thread(Thread-57, started 11756)>, <Thread(Thread-58, started 3872)>, <Thread(Thread-59, started 5888)>, <Thread(Thread-60, started 4092)>, <Thread(Thread-61, started 3840)>, <Thread(Thread-62, initial)>]\n",
      "\n",
      "Downloading page http://xkcd.com/1300...\n",
      "Downloading image https://imgs.xkcd.com/comics/android_boyfriend.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/bill_nye.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/vows.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/1000_comics.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/family_circus.jpg...\n",
      "Downloading image https://imgs.xkcd.com/comics/facebook.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/election.png...\n",
      "Downloading page http://xkcd.com/601...\n",
      "Downloading page http://xkcd.com/201...\n",
      "Downloading page http://xkcd.com/1001...\n",
      "Downloading page http://xkcd.com/1101...\n",
      "Downloading page http://xkcd.com/501...\n",
      "Downloading page http://xkcd.com/101...\n",
      "Downloading image https://imgs.xkcd.com/comics/game_theory.png...\n",
      "Downloading page http://xkcd.com/301...\n",
      "Downloading image https://imgs.xkcd.com/comics/sketchiness.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/limerick.png...\n",
      "Downloading page http://xkcd.com/302...\n",
      "Downloading image https://imgs.xkcd.com/comics/names.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/galilean_moons.png...\n",
      "Downloading page http://xkcd.com/303...\n",
      "Downloading image https://imgs.xkcd.com/comics/complexion.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/compiling.png...\n",
      "Downloading page http://xkcd.com/304...\n",
      "Downloading image https://imgs.xkcd.com/comics/faust_20.png...\n",
      "Downloading page http://xkcd.com/1102...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-49:\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-96-d297308655d6>\", line 8, in downloadXkcd\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\models.py\", line 943, in raise_for_status\n",
      "    raise HTTPError(http_error_msg, response=self)\n",
      "requests.exceptions.HTTPError: 404 Client Error: Not Found for url: https://xkcd.com/0\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 932, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-96-d297308655d6>\", line 9, in downloadXkcd\n",
      "NameError: name 'HTTPError' is not defined\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading image https://imgs.xkcd.com/comics/authorization.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/fastest_growing.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/important_life_lesson.png...\n",
      "Downloading page http://xkcd.com/1301...\n",
      "Downloading page http://xkcd.com/1201...\n",
      "Downloading page http://xkcd.com/401...\n",
      "Downloading page http://xkcd.com/1103...\n",
      "Downloading image https://imgs.xkcd.com/comics/file_extensions.png...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-55:\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 159, in _new_conn\n",
      "    conn = connection.create_connection(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 84, in create_connection\n",
      "    raise err\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 74, in create_connection\n",
      "    sock.connect(sa)\n",
      "TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 670, in urlopen\n",
      "    httplib_response = self._make_request(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 381, in _make_request\n",
      "    self._validate_conn(conn)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 976, in _validate_conn\n",
      "    conn.connect()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 308, in connect\n",
      "    conn = self._new_conn()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 171, in _new_conn\n",
      "    raise NewConnectionError(\n",
      "urllib3.exceptions.NewConnectionError: <urllib3.connection.HTTPSConnection object at 0x00000296E83BB400>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 439, in send\n",
      "    resp = conn.urlopen(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 724, in urlopen\n",
      "    retries = retries.increment(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\retry.py\", line 439, in increment\n",
      "    raise MaxRetryError(_pool, url, error or ResponseError(cause))\n",
      "urllib3.exceptions.MaxRetryError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/game_theory.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E83BB400>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 932, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-96-d297308655d6>\", line 22, in downloadXkcd\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 76, in get\n",
      "    return request('get', url, params=params, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 61, in request\n",
      "    return session.request(method=method, url=url, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 542, in request\n",
      "    resp = self.send(prep, **send_kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 655, in send\n",
      "    r = adapter.send(request, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 516, in send\n",
      "    raise ConnectionError(e, request=request)\n",
      "requests.exceptions.ConnectionError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/game_theory.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E83BB400>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading image https://imgs.xkcd.com/comics/nine.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/laser_scope.jpg...\n",
      "Downloading page http://xkcd.com/1302...\n",
      "Downloading page http://xkcd.com/502...\n",
      "Downloading page http://xkcd.com/701...\n",
      "Downloading image https://imgs.xkcd.com/comics/religions.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/aaaaaa.png...\n",
      "Downloading page http://xkcd.com/901...\n",
      "Downloading page http://xkcd.com/1002...\n",
      "Downloading image https://imgs.xkcd.com/comics/beautiful_dream.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/large_hadron_collider.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/christmas_gps.png...\n",
      "Downloading page http://xkcd.com/801...\n",
      "Downloading page http://xkcd.com/402...\n",
      "Downloading page http://xkcd.com/202...\n",
      "Downloading image https://imgs.xkcd.com/comics/youtube.png...\n",
      "Downloading page http://xkcd.com/1104...\n",
      "Downloading image https://imgs.xkcd.com/comics/year_in_review.png...\n",
      "Downloading page http://xkcd.com/203...\n",
      "Downloading page http://xkcd.com/102...\n",
      "Downloading page http://xkcd.com/1303...\n",
      "Downloading image https://imgs.xkcd.com/comics/hallucinations.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/temperature.png...\n",
      "Downloading page http://xkcd.com/902...\n",
      "Downloading image https://imgs.xkcd.com/comics/integration_by_parts.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/feathers.png...\n",
      "Downloading page http://xkcd.com/204...\n",
      "Downloading image https://imgs.xkcd.com/comics/dark_flow.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/back_to_the_future.jpg...\n",
      "Downloading page http://xkcd.com/503...\n",
      "Downloading image https://imgs.xkcd.com/comics/america.png...\n",
      "Downloading page http://xkcd.com/205...\n",
      "Downloading image https://imgs.xkcd.com/comics/terminology.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/game_ais.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/darmok_and_jalad.png...\n",
      "Downloading page http://xkcd.com/1003...\n",
      "Downloading image https://imgs.xkcd.com/comics/science_valentine.png...\n",
      "Downloading page http://xkcd.com/1202...\n",
      "Downloading page http://xkcd.com/702...\n",
      "Downloading image https://imgs.xkcd.com/comics/girls_and_boys.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/candy_button_paper.png...\n",
      "Downloading page http://xkcd.com/103...\n",
      "Downloading page http://xkcd.com/504...\n",
      "Downloading image https://imgs.xkcd.com/comics/legal_hacks.png...\n",
      "Downloading page http://xkcd.com/505...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-60:\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 159, in _new_conn\n",
      "    conn = connection.create_connection(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 84, in create_connection\n",
      "    raise err\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 74, in create_connection\n",
      "    sock.connect(sa)\n",
      "TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 670, in urlopen\n",
      "    httplib_response = self._make_request(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 381, in _make_request\n",
      "    self._validate_conn(conn)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 976, in _validate_conn\n",
      "    conn.connect()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 308, in connect\n",
      "    conn = self._new_conn()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 171, in _new_conn\n",
      "    raise NewConnectionError(\n",
      "urllib3.exceptions.NewConnectionError: <urllib3.connection.HTTPSConnection object at 0x00000296E75A62B0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 439, in send\n",
      "    resp = conn.urlopen(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 724, in urlopen\n",
      "    retries = retries.increment(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\retry.py\", line 439, in increment\n",
      "    raise MaxRetryError(_pool, url, error or ResponseError(cause))\n",
      "urllib3.exceptions.MaxRetryError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/feathers.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E75A62B0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 932, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-96-d297308655d6>\", line 22, in downloadXkcd\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 76, in get\n",
      "    return request('get', url, params=params, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 61, in request\n",
      "    return session.request(method=method, url=url, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 542, in request\n",
      "    resp = self.send(prep, **send_kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 655, in send\n",
      "    r = adapter.send(request, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 516, in send\n",
      "    raise ConnectionError(e, request=request)\n",
      "requests.exceptions.ConnectionError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/feathers.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E75A62B0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading image https://imgs.xkcd.com/comics/nighttime_stories.jpg...\n",
      "Downloading image https://imgs.xkcd.com/comics/moral_relativity.jpg...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-58:\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 159, in _new_conn\n",
      "    conn = connection.create_connection(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 84, in create_connection\n",
      "    raise err\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 74, in create_connection\n",
      "    sock.connect(sa)\n",
      "TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 670, in urlopen\n",
      "    httplib_response = self._make_request(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 381, in _make_request\n",
      "    self._validate_conn(conn)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 976, in _validate_conn\n",
      "    conn.connect()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 308, in connect\n",
      "    conn = self._new_conn()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 171, in _new_conn\n",
      "    raise NewConnectionError(\n",
      "urllib3.exceptions.NewConnectionError: <urllib3.connection.HTTPSConnection object at 0x00000296E84CE2E0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 439, in send\n",
      "    resp = conn.urlopen(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 724, in urlopen\n",
      "    retries = retries.increment(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\retry.py\", line 439, in increment\n",
      "    raise MaxRetryError(_pool, url, error or ResponseError(cause))\n",
      "urllib3.exceptions.MaxRetryError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/darmok_and_jalad.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E84CE2E0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 932, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-96-d297308655d6>\", line 22, in downloadXkcd\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 76, in get\n",
      "    return request('get', url, params=params, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 61, in request\n",
      "    return session.request(method=method, url=url, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 542, in request\n",
      "    resp = self.send(prep, **send_kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 655, in send\n",
      "    r = adapter.send(request, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 516, in send\n",
      "    raise ConnectionError(e, request=request)\n",
      "requests.exceptions.ConnectionError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/darmok_and_jalad.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E84CE2E0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading image https://imgs.xkcd.com/comics/1000_miles_north.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/golden_hammer.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/a_bunch_of_rocks.png...\n",
      "Downloading page http://xkcd.com/403...\n",
      "Downloading image https://imgs.xkcd.com/comics/convincing_pickup_line.png...\n",
      "Downloading page http://xkcd.com/802...\n",
      "Downloading page http://xkcd.com/506...\n",
      "Downloading image https://imgs.xkcd.com/comics/profile_info.png...\n",
      "Downloading page http://xkcd.com/305...\n",
      "Downloading page http://xkcd.com/1304...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-51:\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 159, in _new_conn\n",
      "    conn = connection.create_connection(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 84, in create_connection\n",
      "    raise err\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 74, in create_connection\n",
      "    sock.connect(sa)\n",
      "TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 670, in urlopen\n",
      "    httplib_response = self._make_request(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 381, in _make_request\n",
      "    self._validate_conn(conn)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 976, in _validate_conn\n",
      "    conn.connect()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 308, in connect\n",
      "    conn = self._new_conn()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 171, in _new_conn\n",
      "    raise NewConnectionError(\n",
      "urllib3.exceptions.NewConnectionError: <urllib3.connection.HTTPSConnection object at 0x00000296E7DF3A30>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 439, in send\n",
      "    resp = conn.urlopen(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 724, in urlopen\n",
      "    retries = retries.increment(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\retry.py\", line 439, in increment\n",
      "    raise MaxRetryError(_pool, url, error or ResponseError(cause))\n",
      "urllib3.exceptions.MaxRetryError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/candy_button_paper.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E7DF3A30>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 932, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-96-d297308655d6>\", line 22, in downloadXkcd\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 76, in get\n",
      "    return request('get', url, params=params, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 61, in request\n",
      "    return session.request(method=method, url=url, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 542, in request\n",
      "    resp = self.send(prep, **send_kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 655, in send\n",
      "    r = adapter.send(request, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 516, in send\n",
      "    raise ConnectionError(e, request=request)\n",
      "requests.exceptions.ConnectionError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/candy_button_paper.png (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E7DF3A30>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading image https://imgs.xkcd.com/comics/rule_34.png...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-50:\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 159, in _new_conn\n",
      "    conn = connection.create_connection(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 84, in create_connection\n",
      "    raise err\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\connection.py\", line 74, in create_connection\n",
      "    sock.connect(sa)\n",
      "TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 670, in urlopen\n",
      "    httplib_response = self._make_request(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 381, in _make_request\n",
      "    self._validate_conn(conn)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 976, in _validate_conn\n",
      "    conn.connect()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 308, in connect\n",
      "    conn = self._new_conn()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connection.py\", line 171, in _new_conn\n",
      "    raise NewConnectionError(\n",
      "urllib3.exceptions.NewConnectionError: <urllib3.connection.HTTPSConnection object at 0x00000296E75B5CD0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 439, in send\n",
      "    resp = conn.urlopen(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\connectionpool.py\", line 724, in urlopen\n",
      "    retries = retries.increment(\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\urllib3\\util\\retry.py\", line 439, in increment\n",
      "    raise MaxRetryError(_pool, url, error or ResponseError(cause))\n",
      "urllib3.exceptions.MaxRetryError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/moral_relativity.jpg (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E75B5CD0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 932, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\threading.py\", line 870, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"<ipython-input-96-d297308655d6>\", line 22, in downloadXkcd\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 76, in get\n",
      "    return request('get', url, params=params, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\api.py\", line 61, in request\n",
      "    return session.request(method=method, url=url, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 542, in request\n",
      "    resp = self.send(prep, **send_kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\sessions.py\", line 655, in send\n",
      "    r = adapter.send(request, **kwargs)\n",
      "  File \"C:\\ProgramData\\Anaconda3\\lib\\site-packages\\requests\\adapters.py\", line 516, in send\n",
      "    raise ConnectionError(e, request=request)\n",
      "requests.exceptions.ConnectionError: HTTPSConnectionPool(host='imgs.xkcd.com', port=443): Max retries exceeded with url: /comics/moral_relativity.jpg (Caused by NewConnectionError('<urllib3.connection.HTTPSConnection object at 0x00000296E75B5CD0>: Failed to establish a new connection: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。'))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading page http://xkcd.com/1203...\n",
      "Downloading image https://imgs.xkcd.com/comics/glass_trolling.png...\n",
      "Downloading image https://imgs.xkcd.com/comics/adam_and_eve.png...\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[1;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3435: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "os.makedirs('xkcd', exist_ok=True) # store comics in ./xkcd\n",
    "def downloadXkcd(startComic, endComic):\n",
    "    for urlNumber in range(startComic, endComic):\n",
    "        # Download the page.\n",
    "        print('Downloading page http://xkcd.com/%s...' % (urlNumber))\n",
    "        res = requests.get('http://xkcd.com/%s' % (urlNumber))\n",
    "        try:\n",
    "            res.raise_for_status()\n",
    "        except HTTPError:\n",
    "            continue\n",
    "            \n",
    "        soup = bs4.BeautifulSoup(res.text)\n",
    "        \n",
    "        # Find the URL of the comic image.\n",
    "        comicElem = soup.select('#comic img')\n",
    "        if comicElem == []:\n",
    "            print('Could not find comic image.')\n",
    "        else:\n",
    "            comicUrl = \"https:\" + comicElem[0].get('src')\n",
    "            # Download the image.\n",
    "            print('Downloading image %s...' % (comicUrl))\n",
    "            res = requests.get(comicUrl)\n",
    "            res.raise_for_status()\n",
    "            # Save the image to ./xkcd.\n",
    "            imageFile = open(os.path.join('xkcd', os.path.basename(comicUrl)), 'wb')\n",
    "            for chunk in res.iter_content(100000):\n",
    "                imageFile.write(chunk)\n",
    "            imageFile.close()\n",
    "# Create and start the Thread objects.\n",
    "downloadThreads = [] # a list of all the Thread objects\n",
    "for i in range(0, 1400, 100): # loops 14 times, creates 14 threads\n",
    "    downloadThread = threading.Thread(target=downloadXkcd, args=(i, i + 99))\n",
    "    downloadThreads.append(downloadThread)\n",
    "    print(\"\\033[41mdownloadThreads\\033[0m\", downloadThreads)\n",
    "    downloadThread.start()\n",
    "\n",
    "# Wait for all threads to end.\n",
    "for downloadThread in downloadThreads:\n",
    "    downloadThread.join()\n",
    "\n",
    "print('Done.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<Thread(Thread-49, stopped 6268)>,\n",
       " <Thread(Thread-50, stopped 12728)>,\n",
       " <Thread(Thread-51, stopped 8952)>,\n",
       " <Thread(Thread-52, stopped 6700)>,\n",
       " <Thread(Thread-53, stopped 8980)>,\n",
       " <Thread(Thread-54, stopped 3216)>,\n",
       " <Thread(Thread-55, stopped 13032)>,\n",
       " <Thread(Thread-56, stopped 6616)>,\n",
       " <Thread(Thread-57, started 11756)>,\n",
       " <Thread(Thread-58, stopped 3872)>,\n",
       " <Thread(Thread-59, stopped 5888)>,\n",
       " <Thread(Thread-60, stopped 4092)>,\n",
       " <Thread(Thread-61, stopped 3840)>]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "downloadThreads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[41m36@\u001b[0mappend                        \n",
      "\u001b[41m37@\u001b[0mclear                         \u001b[41m38@\u001b[0mcopy                          \u001b[41m39@\u001b[0mcount                         \u001b[41m40@\u001b[0mextend                        \n",
      "\u001b[41m41@\u001b[0mindex                         \u001b[41m42@\u001b[0minsert                        \u001b[41m43@\u001b[0mpop                           \u001b[41m44@\u001b[0mremove                        \n",
      "\u001b[41m45@\u001b[0mreverse                       \u001b[41m46@\u001b[0msort                          "
     ]
    }
   ],
   "source": [
    "dir_objectName(downloadThreads)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从 Python 启动其他程序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "利用内建的 subprocess 模块中的 Popen()函数， Python 程序可以启动计算机中的其他程序\n",
    "\n",
    "（Popen()函数名中的 P 表示 process，进程）。\n",
    "\n",
    "如果你打开了一个应用程序的多个实例，每个实例都是同一个程序的不同进程。\n",
    "\n",
    "请记住，启动的程序和你的 Python 程序不在同一线程中运行。\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "[os与subprocess模块执行系统命令 - Leohahah - 博客园👌👌](https://www.cnblogs.com/leohahah/p/12704432.html)\n",
    "\n",
    "建议使用subprocess.Popen来执行系统命令，\n",
    "\n",
    "- 一方面Popen相比os.system()和subprocess.run()是非阻塞模式的，\n",
    "\n",
    "- 另一方面Popen相比os.popen()更加的灵活与全面，所以建议在执行操作系统命令时使用subprocess.Popen对象，\n",
    "\n",
    "- 并同时推荐其with写法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<subprocess.Popen at 0x296e74e8160>"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subprocess.Popen('C:\\\\Windows\\\\System32\\\\calc.exe')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " poll()方法是问你的朋友，她是否执行完毕你给她的代码。\n",
    "    \n",
    "如果这个进程在 poll()调用时仍在运行， poll()方法就返回 None。\n",
    "\n",
    "如果该程序已经终止，它会返回该进程的整数退出代码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "calcProc = subprocess.Popen('c:\\\\Windows\\\\System32\\\\calc.exe')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcProc.poll() == None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "wait()方法就像是等着你的朋友执行完她的代码，然后你继续执行你的代码。\n",
    "\n",
    "wait()方法将阻塞，直到启动的进程终止。\n",
    "\n",
    "如果你希望你的程序暂停，直到用户完成与其他程序，这非常有用。\n",
    "\n",
    "wait()的返回值是进程的整数退出代码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcProc.wait()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcProc.poll()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "打开了计算器程序。\n",
    "\n",
    "在它仍在运行时，我们检查 poll()是否返回None。它应该返回 None，因为该进程仍在运行。\n",
    "\n",
    "然后，我们关闭计算器程序，并对已终止的进程调用 wait()。 \n",
    "\n",
    "wait()和 poll()现在返回 0，说明该进程终止且无错。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 向 Popen()传递命令行参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "向 Popen()传递一个列表，作为唯一的参数。\n",
    "\n",
    "该列表中的第一个字符串是要启动的程序的可执行文件名，所有后续的字符串将是该程序启动时，传递给该程序的命令行参数。\n",
    "\n",
    "实际上，这个列表将作为被启动程序的 sys.argv 的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<subprocess.Popen at 0x296e7979670>"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 这不仅会启动记事本应用程序，也会让它立即打开 C:\\hello.txt\n",
    "\"\"\"\n",
    "大多数 GUI 应用程序将接受一个参数， 表示应用程序启动时立即打开的文件\n",
    "\"\"\"\n",
    "subprocess.Popen(['C:\\\\Windows\\\\notepad.exe', 'C:\\\\hello.txt'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task Scheduler、 launchd 和 cron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "安排应用程序在特定的时间启动\n",
    "\n",
    "- Windows 上的 Task Scheduler， \n",
    "\n",
    "- OS X 上的launchd，\n",
    "\n",
    "- Linux 上的 cron 调度程序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 用 Python 打开网站"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "webbrowser.open()函数可以从程序启动 Web 浏览器，打开指定的网站，\n",
    "\n",
    "而<font color=red>不是</font>用 subprocess.Popen()打开浏览器应用程序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "webbrowser.open(\"www.baidu.com\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<subprocess.Popen at 0x296e9a36400>"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subprocess.Popen([\"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe\", \"www.baidu.com\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 运行其他 Python 脚本"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>不同</font>于将 Python 程序导入为一个模块，\n",
    "\n",
    "如果 Python 程序启动了另一个 Python程序，两者将在独立的进程中运行，不能分享彼此的变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<subprocess.Popen object at 0x00000296E99559D0>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(subprocess.Popen, None)"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = subprocess.Popen(['python.exe', 'pformat_myCats.py'])\n",
    "type(p), print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[b\"[{'desc': 'chubby', 'name': 'Zophie'}, {'desc': 'fluffy', 'name': 'Pooka'}]\\r\\n\"]"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = subprocess.Popen(['python.exe', 'pformat_myCats.py'], stdout=subprocess.PIPE)\n",
    "p.stdout.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\"[{'desc': 'chubby', 'name': 'Zophie'}, {'desc': 'fluffy', 'name': 'Pooka'}]\\r\\n\"\n"
     ]
    }
   ],
   "source": [
    "with subprocess.Popen(['python.exe', 'pformat_myCats.py'], shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as p:\n",
    "    for line in p.stdout.readlines():\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 用默认的应用程序打开文件"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Windows上，这是 start 程序。\n",
    "\n",
    "在 OS X 上，这是 open 程序。\n",
    "\n",
    "在 Ubuntu Linux 上，这是 see 程序\n",
    "\n",
    "---\n",
    "\n",
    "传入shell=True 关键字参数，这只在 Windows 上需要。\n",
    "\n",
    "操作系统知道所有的文件关联，能弄清楚应该启动哪个程序，\n",
    "\n",
    "比如Notepad.exe，来处理hello.txt 文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<subprocess.Popen at 0x296e8667250>"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileObj = open('hello.txt', 'w')\n",
    "fileObj.write('Hello world!')\n",
    "fileObj.close()\n",
    "\"\"\"\n",
    "shell: If true, the command will be executed through the shell.\n",
    "\"\"\"\n",
    "subprocess.Popen(['start', 'hello.txt'], shell=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 项目：简单的倒计时程序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "写一个倒计时程序，在倒计时结束时报警。\n",
    "\n",
    "总的来说，程序要做到：\n",
    "\n",
    "- 从 60 倒数。\n",
    "\n",
    "- 倒数至 0 时播放声音文件（alarm.wav）。\n",
    "\n",
    "这意味着代码将需要做到以下几点：\n",
    "\n",
    "- 在显示倒计时的每个数字之间，调用 time.sleep()暂停一秒。\n",
    "- 调用 subprocess.Popen()，用默认的应用程序播放声音文件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "321"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<subprocess.Popen at 0x296e9a4e760>"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  A simple countdown script\n",
    "timeLeft = 3\n",
    "while timeLeft > 0:\n",
    "    print(timeLeft, end='')\n",
    "    time.sleep(1)\n",
    "    timeLeft = timeLeft - 1\n",
    "# At the end of the countdown, play a sound file.\n",
    "filePath = \"C:/Users/Administrator/Desktop/周華健!咱們音樂教室不NG的!【龍兄虎弟】精華.mp4\"\n",
    "subprocess.Popen(['start', filePath], shell=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
